package com.baixun.gassystem.service;


import com.baixun.gascommon.config.ApiConfig;
import com.baixun.gascommon.utils.HttpClientUtil;
import com.baixun.gascommon.utils.RedisUtils;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.sql.*;
import java.util.HashMap;

/**
 * @program: 上海燃气驾驶舱
 * @description: pointId视频监控，并将数据保存到数据库中的 video_playback_records 表中。
 * @author: yesong
 **/

// 此方法不再使用直接调取evs接口

@Service
public class VideoService {

    @Autowired
    private ApiService apiService;

    @Autowired
    private RedisUtils redisUtils;

    private static final String LAST_EXECUTION_TIME_KEY = "LAST_EXECUTION_TIME";
    private static final String TOKEN_KEY = "SAAS_SESSION_TOKEN";

    // 获取并处理签名URL数据，保存到数据库
   // @Scheduled(fixedRate = 3600000 * 24) // 24小时执行一次
    public void getSignedUrlsAndSaveToDatabase() throws Exception {
        // 获取当前时间作为本次任务的结束时间
        long currentExecutionTime = System.currentTimeMillis();

        // 从 Redis 获取上次执行时间，如果不存在则默认获取 24 小时前的数据
        String lastExecutionTimeStr = redisUtils.get(LAST_EXECUTION_TIME_KEY);
        long lastExecutionTime;

        if (lastExecutionTimeStr == null) {
            // 如果 Redis 中没有记录，默认获取 24 小时前的数据
            lastExecutionTime = currentExecutionTime - 24 * 3600000;
        } else {
            lastExecutionTime = Long.parseLong(lastExecutionTimeStr);
        }

        // 获取接口数据，传递上次执行的时间作为参数（假设API支持时间过滤）
        String pointsData = apiService.getPointsList();


        // 将返回的字符串解析为 JSON 对象
        JSONObject jsonObject = new JSONObject(pointsData);
        // 获取 data 数组
        JSONArray dataArray = jsonObject.getJSONArray("data");

        // 遍历 data 数组，提取 pointId，并获取视频签名链接
        for (int i = 0; i < dataArray.length(); i++) {
            JSONObject point = dataArray.getJSONObject(i);
            long pointId = point.getLong("pointId");

            // 假设协议是固定的，如 "RTSP"
            String protocol = "RTSP";

            // 获取签名URL
            String signedUrl = getSignedUrlForPoint(pointId, protocol);

            // 保存到数据库
            saveVideoPlaybackRecord(pointId, protocol, signedUrl);
        }

        // 将本次任务的结束时间保存到 Redis 供下次任务使用
        redisUtils.set(LAST_EXECUTION_TIME_KEY, String.valueOf(currentExecutionTime));
    }

    // 获取点位的签名URL
    private String getSignedUrlForPoint(long pointId, String protocol) throws Exception {
        // 从 Redis 中获取 token
        String token = getTokenFromRedis();
        if (token == null) {
            throw new Exception("No valid token found in Redis.");
        }

        // 构建请求URL
        String signedUrl = ApiConfig.DOMAIN + "/api/v2/points/" + pointId + "/signed_url?protocol=" + protocol;

        // 设置请求头，包含动态获取的 token
        HashMap<String, String> headers = new HashMap<>();
        headers.put("Cookie", "SAAS_SESSION=" + token);
        headers.put("Content-Type", "application/json; charset=UTF-8");

        // 调用 GET 接口获取播放链接
        return HttpClientUtil.sendGetRequest(signedUrl, headers);
    }

    // 保存视频播放记录到数据库
    private void saveVideoPlaybackRecord(long pointId, String protocol, String signedUrl) throws SQLException {
        // 使用 ON DUPLICATE KEY UPDATE 语法
        String sql = "INSERT INTO video_playback_records (point_id, protocol, url, create_time) " +
                "VALUES (?, ?, ?, NOW()) " +
                "ON DUPLICATE KEY UPDATE url = VALUES(url), protocol = VALUES(protocol), create_time = NOW()";
        // 检查 point_id 是否已存在
        String checkSql = "SELECT COUNT(*) FROM video_playback_records WHERE point_id = ?";


        // 获取数据库连接
        Connection conn = getDatabaseConnection();
        try (
                PreparedStatement checkStmt = conn.prepareStatement(checkSql);
                PreparedStatement stmt = conn.prepareStatement(sql)
        ) {
            // 检查 pointId 是否已存在
            checkStmt.setLong(1, pointId);
            ResultSet rs = checkStmt.executeQuery();

            if (rs.next() && rs.getInt(1) > 0) {
                // 如果 pointId 已存在，则跳过插入操作
                System.out.println("记录已存在，跳过插入操作");
                return;
            }

            // 设置插入语句的参数
            stmt.setLong(1, pointId); // 设置 point_id
            stmt.setString(2, protocol); // 设置协议
            stmt.setString(3, signedUrl); // 设置签名 URL

            // 执行插入操作
            stmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            throw new SQLException("数据库插入或更新失败：" + e.getMessage());
        } finally {
            if (conn != null) {
                conn.close();
            }
        }
    }

    // 模拟从 Redis 中获取 Token 的方法
    public String getTokenFromRedis() {
        return redisUtils.get(TOKEN_KEY);
    }

    // 获取数据库连接
    private Connection getDatabaseConnection() throws SQLException {
        String url = "jdbc:mysql://gz-cdb-a1k9mjhj.sql.tencentcdb.com:29414/shanghai-gas";
        String user = "root";
        String password = "clRDS@1010&&";
        return DriverManager.getConnection(url, user, password);
    }

}
